home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 April: Mac OS SDK / Dev.CD Apr 00 SDK1.toast / Development Kits / Mac OS / UPDATE- Int&Libs 3.2 / PInterfaces / ATSUnicode.p < prev    next >
Encoding:
Text File  |  1999-05-25  |  35.4 KB  |  611 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        ATSUnicode.p
  3.  
  4.      Contains:    Public interfaces for Apple Type Services for Unicode Imaging
  5.  
  6.      Version:    Technology:    Allegro
  7.                  Release:    Veronica Seed, Use with 3.2 Universal Interfaces
  8.  
  9.      Copyright:    © 1997-1999 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT ATSUnicode;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __ATSUNICODE__}
  27. {$SETC __ATSUNICODE__ := 1}
  28.  
  29. {$I+}
  30. {$SETC ATSUnicodeIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __ATSLAYOUTTYPES__}
  34. {$I ATSLayoutTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __SFNTLAYOUTTYPES__}
  37. {$I SFNTLayoutTypes.p}
  38. {$ENDC}
  39.  
  40. {$IFC UNDEFINED __MACTYPES__}
  41. {$I MacTypes.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __MACMEMORY__}
  44. {$I MacMemory.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __QUICKDRAW__}
  47. {$I Quickdraw.p}
  48. {$ENDC}
  49. {$IFC UNDEFINED __TEXTCOMMON__}
  50. {$I TextCommon.p}
  51. {$ENDC}
  52.  
  53.  
  54. {$PUSH}
  55. {$ALIGN MAC68K}
  56. {$LibExport+}
  57.  
  58. {**********}
  59. {    Types    }
  60. {**********}
  61. {
  62.       UniCharArrayHandle is a handle type to correspond to 
  63.       UniCharArrayPtr, defined in Unicode.h.  It refers 
  64.       to a handle, interpreted as a pointer to an array 
  65.       of UniChar's (UInt16's).
  66. }
  67.  
  68.  
  69. TYPE
  70.     UniCharArrayHandle                    = ^UniCharArrayPtr;
  71. {
  72.       UniCharArrayOffset is used to indicate an offset 
  73.       into an array of UniChar's (UInt16's).  
  74. }
  75.     UniCharArrayOffset                    = UInt32;
  76. {
  77.       ATSUTextMeasurement is specific to ATSUI in that measurement
  78.       quantities are in fractional Fixed format instead of shorts
  79.       used in QuickDraw Text.  This provides exact outline metrics and
  80.       line specifications such as line width, ascent, descent, and so on.  
  81. }
  82.     ATSUTextMeasurement                    = Fixed;
  83. {
  84.       ATSUFontID indicates a particular font family and face.  
  85.       ATSUFontID's are not guaranteed to remain constant across 
  86.       reboots.  Clients should use the font's unique name to 
  87.       get a font token to store in documents which is 
  88.       guaranteed to remain constant across reboots. 
  89. }
  90.     ATSUFontID                            = UInt32;
  91. {
  92.       ATSUFontFeatureType and ATSUFontFeatureSelector are used 
  93.       to identify font features.  
  94. }
  95.     ATSUFontFeatureType                    = UInt16;
  96.     ATSUFontFeatureSelector                = UInt16;
  97. {
  98.       ATSUFontVariationAxis and ATSUFontVariationValue are used 
  99.       in connection with font variations.  
  100. }
  101.     ATSUFontVariationAxis                = FourCharCode;
  102.     ATSUFontVariationValue                = Fixed;
  103. {
  104.       ATSUTextLayout is used to store the attribute information 
  105.       associated with a contiguous block of UniChar's (UInt16's) 
  106.       in memory.  It's typed to be an opaque structure.  
  107. }
  108.     ATSUTextLayout = ^LONGINT;
  109. {
  110.       ATSUStyle is used to store a set of individual attributes, 
  111.       font features, and font variations.  It's typed to be 
  112.       an opaque structure.  
  113. }
  114.     ATSUStyle = ^LONGINT;
  115. {
  116.       ATSUAttributeTag is used to indicate the particular type 
  117.       of attribute under consideration:  font, size, color, 
  118.       and so on.  
  119.       Each style run may have at most one attribute with a 
  120.       given ATSUAttributeTag (i.e., a style run can't have 
  121.       more than one font or size) but may have none.  
  122. }
  123.     ATSUAttributeTag                    = UInt32;
  124. {
  125.       ATSUAttributeValuePtr is used to provide generic access 
  126.       to storage of attribute values, which vary in size.
  127. }
  128.     ATSUAttributeValuePtr                = Ptr;
  129. {
  130.       ATSUAttributeInfo is used to provide a tag/size pairing.  
  131.       This makes it possible to provide the client information   
  132.       about all the attributes for a given range of text.  This   
  133.       structure is only used to return to the client information   
  134.       about a complete set of attributes.  An array of   
  135.       ATSUAttributeInfos is passed as a parameter so that the   
  136.       client can find out what attributes are set and what their   
  137.       individual sizes are; with that information, they can then   
  138.       query about the values of the attributes they're interested   
  139.       in.  Because arrays of ATSUAttributeInfos are used as parameters   
  140.       to functions, they have to be of a fixed size, hence the   
  141.       value is not included in the structure.  
  142. }
  143.     ATSUAttributeInfoPtr = ^ATSUAttributeInfo;
  144.     ATSUAttributeInfo = RECORD
  145.         fTag:                    ATSUAttributeTag;
  146.         fValueSize:                ByteCount;
  147.     END;
  148.  
  149. {
  150.       ATSUCaret contains the complete information needed to render a
  151.       caret.  fX and fY is the position of one of the caret's ends
  152.       relative to the origin position of the line the caret belongs.
  153.       fDeltaX and fDeltaY is the position of the caret's other end.
  154.       Hence, to draw a caret, simply call MoveTo(fX, fY) followed by
  155.       LineTo(fDeltaX, fDeltaY) or equivalent.  The ATSUCaret will
  156.       contain the positions needed to draw carets on angled lines
  157.       and reflect angled carets and leading/trailing split caret
  158.       appearances.
  159. }
  160.     ATSUCaretPtr = ^ATSUCaret;
  161.     ATSUCaret = RECORD
  162.         fX:                        Fixed;
  163.         fY:                        Fixed;
  164.         fDeltaX:                Fixed;
  165.         fDeltaY:                Fixed;
  166.     END;
  167.  
  168. {
  169.       ATSUCursorMovementType currently can take three values 
  170.       (kATSUByCharacter, kATSUByCluster, and kATSUByWord) 
  171.       and is used to indicate how much to move the cursor.  
  172. }
  173.     ATSUCursorMovementType                = UInt16;
  174. {
  175.       ATSUVerticalCharacterType currently can take two values 
  176.       (kATSUStronglyVertical, and kATSUStronglyHorizontal) and 
  177.       is used to indicate whether text is to be laid out as 
  178.       vertical glyphs or horizontal glyphs.  
  179. }
  180.     ATSUVerticalCharacterType            = UInt16;
  181. {
  182.       ATSUStyleComparison is an enumeration with four values 
  183.       (kATUStyleUnequal, ATSUStyleContains, kATSUStyleEquals, 
  184.       and kATSUStyleContainedBy), and is used by ATSUCompareStyles() 
  185.       to indicate if the first style parameter contains as a 
  186.       proper subset, is equal to, or is contained by the second 
  187.       style parameter.
  188. }
  189.     ATSUStyleComparison                    = UInt16;
  190. {
  191.       ATSUFontFallbackMethod type defines the type of heap or memory callback
  192.       method ATSUI is to follow iin all its permanent memory allocations for
  193.       it clients.
  194. }
  195.     ATSUFontFallbackMethod                = UInt16;
  196. {
  197.       ATSUMemoryCallbacks is a union struct that allows the ATSUI 
  198.       client to specify a specific heap for ATSUI use or allocation
  199.       callbacks of which ATSUI is to use each time ATSUI performs a
  200.       memory operation (alloc, grow, free).
  201. }
  202. {$IFC TYPED_FUNCTION_POINTERS}
  203.     ATSUCustomAllocFunc = FUNCTION(refCon: UNIV Ptr; howMuch: ByteCount): Ptr; C;
  204. {$ELSEC}
  205.     ATSUCustomAllocFunc = ProcPtr;
  206. {$ENDC}
  207.  
  208. {$IFC TYPED_FUNCTION_POINTERS}
  209.     ATSUCustomFreeFunc = PROCEDURE(refCon: UNIV Ptr; doomedBlock: UNIV Ptr); C;
  210. {$ELSEC}
  211.     ATSUCustomFreeFunc = ProcPtr;
  212. {$ENDC}
  213.  
  214. {$IFC TYPED_FUNCTION_POINTERS}
  215.     ATSUCustomGrowFunc = FUNCTION(refCon: UNIV Ptr; oldBlock: UNIV Ptr; oldSize: ByteCount; newSize: ByteCount): Ptr; C;
  216. {$ELSEC}
  217.     ATSUCustomGrowFunc = ProcPtr;
  218. {$ENDC}
  219.  
  220.     ATSUMemoryCallbacksPtr = ^ATSUMemoryCallbacks;
  221.     ATSUMemoryCallbacks = RECORD
  222.         CASE INTEGER OF
  223.         0: (
  224.             Alloc:                ATSUCustomAllocFunc;
  225.             Free:                ATSUCustomFreeFunc;
  226.             Grow:                ATSUCustomGrowFunc;
  227.             memoryRefCon:        Ptr;
  228.            );
  229.         1: (
  230.             heapToUse:            THz;
  231.             );
  232.     END;
  233.  
  234. {
  235.       ATSUHeapSpec provides allows the ATSUI client a means of
  236.       specifying the heap ATSUI should allocate it's dynamic memory
  237.       from or that ATSUI should use the memory callback provided by
  238.       the client.
  239. }
  240.     ATSUHeapSpec                        = UInt16;
  241. {
  242.       ATSUMemorySetting is used to store the results from a ATSUSetMemoryAlloc
  243.       or a ATSUGetCurrentMemorySetting call.  It can also be used to change the
  244.       current ATSUMemorySetting by passing it into the ATSUSetCurrentMemorySetting
  245.       call.
  246. }
  247.     ATSUMemorySetting = ^LONGINT;
  248. {**************************************************}
  249. {    Gestalt selectors                                }
  250. {        Move into Gestalt.i when they're stable!!!!    }
  251. {**************************************************}
  252.  
  253. CONST
  254.     gestaltATSUVersion            = 'uisv';
  255.     gestaltATSUFeatures            = 'uisf';
  256.  
  257.     gestaltOriginalATSUVersion    = $00010000;
  258.     gestaltATSUUpdate1            = $00020000;
  259.  
  260.     gestaltATSUTrackingFeature    = $00000001;
  261.     gestaltATSUMemoryFeature    = $00000001;
  262.     gestaltATSUFallbacksFeature    = $00000001;
  263.     gestaltATSUGlyphBoundsFeature = $00000001;
  264.     gestaltATSULineControlFeature = $00000001;
  265.     gestaltATSULayoutCreateAndCopyFeature = $00000001;
  266.     gestaltATSULayoutCacheClearFeature = $00000001;
  267.  
  268. {**************}
  269. {    Error codes    }
  270. {**************}
  271.     kATSUInvalidTextLayoutErr    = -8790;                        {     An attempt was made to use a ATSUTextLayout  }
  272.                                                                 {     which hadn't been initialized or is otherwise  }
  273.                                                                 {     in an invalid state.  }
  274.     kATSUInvalidStyleErr        = -8791;                        {     An attempt was made to use a ATSUStyle which   }
  275.                                                                 {     hadn't been properly allocated or is otherwise   }
  276.                                                                 {     in an invalid state.   }
  277.     kATSUInvalidTextRangeErr    = -8792;                        {     An attempt was made to extract information    }
  278.                                                                 {     from or perform an operation on a ATSUTextLayout  }
  279.                                                                 {     for a range of text not covered by the ATSUTextLayout.   }
  280.     kATSUFontsMatched            = -8793;                        {     This is not an error code but is returned by     }
  281.                                                                 {     ATSUMatchFontsToText() when changes need to     }
  282.                                                                 {     be made to the fonts associated with the text.   }
  283.     kATSUFontsNotMatched        = -8794;                        {     This value is returned by ATSUMatchFontsToText()     }
  284.                                                                 {     when the text contains Unicode characters which     }
  285.                                                                 {     cannot be represented by any installed font.   }
  286.     kATSUNoCorrespondingFontErr    = -8795;                        {     This value is retrned by font ID conversion  }
  287.                                                                 {     routines ATSUFONDtoFontID() and ATSUFontIDtoFOND()  }
  288.                                                                 {     to indicate that the input font ID is valid but  }
  289.                                                                 {     there is no conversion possible.  For example,  }
  290.                                                                 {     data-fork fonts can only be used with ATSUI not  }
  291.                                                                 {     the FontManager, and so converting an ATSUIFontID  }
  292.                                                                 {     for such a font will fail.    }
  293.     kATSUInvalidFontErr            = -8796;                        {     Used when an attempt was made to use an invalid font ID. }
  294.     kATSUInvalidAttributeValueErr = -8797;                        {     Used when an attempt was made to use an attribute with  }
  295.                                                                 {     a bad or undefined value.   }
  296.     kATSUInvalidAttributeSizeErr = -8798;                        {     Used when an attempt was made to use an attribute with a  }
  297.                                                                 {     bad size.   }
  298.     kATSUInvalidAttributeTagErr    = -8799;                        {     Used when an attempt was made to use a tag value that }
  299.                                                                 {     was not appropriate for the function call it was used.   }
  300.     kATSUInvalidCacheErr        = -8800;                        {     Used when an attempt was made to read in style data  }
  301.                                                                 {     from an invalid cache.  Either the format of the  }
  302.                                                                 {     cached data doesn't match that used by Apple Type  }
  303.                                                                 {     Services for Unicode™ Imaging, or the cached data  }
  304.                                                                 {     is corrupt.   }
  305.     kATSUNotSetErr                = -8801;                        {     Used when the client attempts to retrieve an attribute,  }
  306.                                                                 {     font feature, or font variation from a style when it  }
  307.                                                                 {     hadn't been set.  In such a case, the default value will }
  308.                                                                 {     be returned for the attribute's value. }
  309.     kATSUNoStyleRunsAssignedErr    = -8802;                        {     Used when an attempt was made to measure, highlight or draw }
  310.                                                                 {     a ATSUTextLayout object that has no styleRuns associated with it. }
  311.     kATSUQuickDrawTextErr        = -8803;                        {     Used when QuickDraw Text encounters an error rendering or measuring }
  312.                                                                 {     a line of ATSUI text. }
  313.     kATSULowLevelErr            = -8804;                        {     Used when an error was encountered within the low level ATS  }
  314.                                                                 {     mechanism performing an operation requested by ATSUI. }
  315.     kATSUNoFontCmapAvailableErr    = -8805;                        {     Used when no CMAP table can be accessed or synthesized for the  }
  316.                                                                 {     font passed into a SetAttributes Font call. }
  317.     kATSUNoFontScalerAvailableErr = -8806;                        {     Used when no font scaler is available for the font passed }
  318.                                                                 {     into a SetAttributes Font call. }
  319.     kATSUCoordinateOverflowErr    = -8807;                        {     Used to indicate the coordinates provided to an ATSUI routine caused }
  320.                                                                 {     a coordinate overflow (i.e. > 32K). }
  321.     kATSULastErr                = -8808;                        {     The last ATSUI error code. }
  322.  
  323. {*****************************************************************************}
  324. {    ATSUI Attribute tags:  Apple reserves values 0 to 65,535 (0 to 0x0000FFFF) }
  325. {    ATSUI clients may create their own tags with any other value               }
  326. {*****************************************************************************}
  327. {    Line Control Attribute Tags }
  328.     kATSULineWidthTag            = 1;                            {     Type:            ATSUTextMeasurement }
  329.                                                                 {     Default value:    0 }
  330.     kATSULineRotationTag        = 2;                            {     Type:            Fixed (fixed value in degrees in right-handed coordinate system) }
  331.                                                                 {     Default value:    0 }
  332.     kATSULineDirectionTag        = 3;                            {     Type:            Boolean; values 0 or 1 (see below for value identities) }
  333.                                                                 {     Default value:    GetSysDirection() ? kATSURightToLeftBaseDirection : kATSULeftToRightBaseDirection }
  334.     kATSULineJustificationFactorTag = 4;                        {     Type:            Fract between 0 and 1 }
  335.                                                                 {     Default value:    kATSUNoJustification }
  336.     kATSULineFlushFactorTag        = 5;                            {     Type:            Fract between 0 and 1  }
  337.                                                                 {     Default value:    kATSUStartAlignment }
  338.     kATSULineBaselineValuesTag    = 6;                            {     Type:            BslnBaselineRecord }
  339.                                                                 {     Default value:    All zeros.  Calculated from other style attributes (e.g., font and point size) }
  340.     kATSULineLayoutOptionsTag    = 7;                            {     Type:            UInt32 }
  341.                                                                 {     Default value:    kATSLineNoLayoutOptions - other options listed in ATSLayoutTypes.h }
  342.     kATSULineAscentTag            = 8;                            {     Type:            ATSUTextMeasurement }
  343.                                                                 {     Default value:    kATSUseLineHeight }
  344.                                                                 {     Type:            ATSUTextMeasurement }
  345.     kATSULineDescentTag            = 9;                            {     Default value:    kATSUseLineHeight }
  346.  
  347. {    Run Style Attribute Tags }
  348.                                                                 {  QuickDraw compatibility tags  }
  349.     kATSUQDBoldfaceTag            = 256;                            {     Type:            Boolean     }
  350.                                                                 {     Default value:    false }
  351.     kATSUQDItalicTag            = 257;                            {     Type:            Boolean         }
  352.                                                                 {     Default value:    false }
  353.     kATSUQDUnderlineTag            = 258;                            {     Type:            Boolean     }
  354.                                                                 {     Default value:    false }
  355.     kATSUQDCondensedTag            = 259;                            {     Type:            Boolean     }
  356.                                                                 {     Default value:    false }
  357.     kATSUQDExtendedTag            = 260;                            {     Type:            Boolean     }
  358.                                                                 {     Default value:    false }
  359.                                                                 {  Common run tags  }
  360.     kATSUFontTag                = 261;                            {     Type:            ATSUFontID     }
  361.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptAppFond ) }
  362.     kATSUSizeTag                = 262;                            {     Type:            Fixed     }
  363.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptAppFondSize )     }
  364.     kATSUColorTag                = 263;                            {     Type:            RGBColor     }
  365.                                                                 {     Default value:    (0, 0, 0) }
  366.                                                                 {     Less common run tags  }
  367.     kATSULanguageTag            = 264;                            {     Type:            RegionCode     }
  368.                                                                 {     Default value:    GetScriptVariable( smSystemScript, smScriptLang ) }
  369.     kATSUVerticalCharacterTag    = 265;                            {     Type:            ATSUVerticalCharacterType     }
  370.                                                                 {     Default value:    kATSUStronglyHorizontal }
  371.     kATSUImposeWidthTag            = 266;                            {     Type:            ATSUTextMeasurement }
  372.                                                                 {     Default value:    all glyphs use their own font defined advance widths }
  373.     kATSUBeforeWithStreamShiftTag = 267;                        {     Type:            Fixed }
  374.                                                                 {     Default value:    0 }
  375.     kATSUAfterWithStreamShiftTag = 268;                            {     Type:            Fixed }
  376.                                                                 {     Default value:    0 }
  377.     kATSUCrossStreamShiftTag    = 269;                            {     Type:            Fixed }
  378.                                                                 {     Default value:    0 }
  379.     kATSUTrackingTag            = 270;                            {     Type:            Fixed }
  380.                                                                 {     Default value:    kATSNoTracking }
  381.     kATSUHangingInhibitFactorTag = 271;                            {     Type:            Fract between 0 and 1 }
  382.                                                                 {     Default value:    0 }
  383.     kATSUKerningInhibitFactorTag = 272;                            {     Type:            Fract between 0 and 1 }
  384.                                                                 {     Default value:    0 }
  385.     kATSUDecompositionFactorTag    = 273;                            {     Type:            Fixed (-1.0 -> 1.0) }
  386.                                                                 {     Default value:    0 }
  387.     kATSUBaselineClassTag        = 274;                            {     Type:            BslnBaselineClass  (see SFNTLayoutTypes.h) }
  388.                                                                 {     Default value:    kBSLNRomanBaseline - set to kBSLNNoBaselineOverride to use intrinsic baselines }
  389.     kATSUPriorityJustOverrideTag = 275;                            {     Type:            ATSJustPriorityWidthDeltaOverrides (see ATSLayoutTypes.h) }
  390.                                                                 {     Default value:    all zeros }
  391.     kATSUNoLigatureSplitTag        = 276;                            {     Type:            Boolean }
  392.                                                                 {     Default value:    false - ligatures and compound characters have divisable components. }
  393.     kATSUNoCaretAngleTag        = 277;                            {     Type:            Boolean }
  394.                                                                 {     Default value:    false - use the character's angularity to determine its boundaries }
  395.     kATSUSuppressCrossKerningTag = 278;                            {     Type:            Boolean }
  396.                                                                 {     Default value:    false - do not suppress automatic cross kerning (defined by font) }
  397.     kATSUNoOpticalAlignmentTag    = 279;                            {     Type:            Boolean }
  398.                                                                 {     Default value:    false - do not suppress character's automatic optical positional alignment }
  399.     kATSUForceHangingTag        = 280;                            {     Type:            Boolean }
  400.                                                                 {     Default value:    false - do not force the character's to hang beyond the line boundaries }
  401.     kATSUNoSpecialJustificationTag = 281;                        {     Type:            Boolean }
  402.                                                                 {     Default value:    false - perform post-compensation justification if needed }
  403.     kATSUMaxStyleTag            = 282;                            {     This is just for convenience - the upper limit of the ATSUStyle attribute tags  }
  404.     kATSUMaxATSUITagValue        = 65535;                        {     This is the maximum Apple ATSUI reserved tag value.  Client defined tags must be larger. }
  405.  
  406. {******************************}
  407. {    Enumerations and constants    }
  408. {******************************}
  409. { Cursor movement }
  410.     kATSUByCharacter            = 0;
  411.     kATSUByCluster                = 1;
  412.     kATSUByWord                    = 2;
  413.  
  414. { Vertical text types }
  415.     kATSUStronglyHorizontal        = 0;
  416.     kATSUStronglyVertical        = 1;
  417.  
  418. { Line direction types (used for kATSULineDirectionTag values) }
  419.     kATSULeftToRightBaseDirection = 0;                            {     Impose left-to-right or top-to-bottom dominant direction  }
  420.     kATSURightToLeftBaseDirection = 1;                            {     Impose right-to-left or bottom-to-top dominant direction  }
  421.  
  422. { Style comparison types }
  423.     kATSUStyleUnequal            = 0;
  424.     kATSUStyleContains            = 1;
  425.     kATSUStyleEquals            = 2;
  426.     kATSUStyleContainedBy        = 3;
  427.  
  428. { Font Fallback methods }
  429.     kATSUDefaultFontFallbacks    = 0;
  430.     kATSULastResortOnlyFallback    = 1;
  431.     kATSUSequentialFallbacksPreferred = 2;
  432.     kATSUSequentialFallbacksExclusive = 3;
  433.  
  434. { ATSUI heap or memory allocation specifiers (of type ATSUHeapSpec) }
  435.     kATSUUseCurrentHeap            = 0;
  436.     kATSUUseAppHeap                = 1;
  437.     kATSUUseSpecificHeap        = 2;
  438.     kATSUUseCallbacks            = 3;
  439.  
  440. { LineFlushFactor convenience defined values }
  441.     kATSUStartAlignment            = $00000000;
  442.     kATSUEndAlignment            = $40000000;
  443.     kATSUCenterAlignment        = $20000000;
  444.  
  445. { LineJustificationFactor convenience defined values }
  446.     kATSUNoJustification        = $00000000;
  447.     kATSUFullJustification        = $40000000;
  448.  
  449. { Other constants    }
  450.     kATSUInvalidFontID            = 0;
  451.  
  452.  
  453.     kATSUUseLineControlWidth    = $7FFFFFFF;
  454.  
  455.  
  456.     kATSUNoSelector                = $0000FFFF;
  457.  
  458.  
  459.     kATSUUseGrafPortPenLoc        = $FFFFFFFF;
  460.     kATSUClearAll                = $FFFFFFFF;
  461.  
  462.  
  463.     kATSUFromTextBeginning        = $FFFFFFFF;
  464.     kATSUToTextEnd                = $FFFFFFFF;
  465.  
  466.  
  467. {**************}
  468. {    Functions    }
  469. {**************}
  470.  
  471. {    Clipboard support, flattened style version 0 (is is advised to not use these routines and perform your own flattening)    }
  472. FUNCTION ATSUCopyToHandle(iStyle: ATSUStyle; oStyleHandle: Handle): OSStatus; C;
  473. FUNCTION ATSUPasteFromHandle(iStyle: ATSUStyle; iStyleHandle: Handle): OSStatus; C;
  474. {    Memory allocation specification functions    }
  475. FUNCTION ATSUCreateMemorySetting(iHeapSpec: ATSUHeapSpec; VAR iMemoryCallbacks: ATSUMemoryCallbacks; VAR oMemorySetting: ATSUMemorySetting): OSStatus; C;
  476. FUNCTION ATSUSetCurrentMemorySetting(iMemorySetting: ATSUMemorySetting): OSStatus; C;
  477. FUNCTION ATSUGetCurrentMemorySetting: ATSUMemorySetting; C;
  478. FUNCTION ATSUDisposeMemorySetting(iMemorySetting: ATSUMemorySetting): OSStatus; C;
  479. {    Basic style functions    }
  480. FUNCTION ATSUCreateStyle(VAR oStyle: ATSUStyle): OSStatus; C;
  481. FUNCTION ATSUCreateAndCopyStyle(iStyle: ATSUStyle; VAR oStyle: ATSUStyle): OSStatus; C;
  482. FUNCTION ATSUDisposeStyle(iStyle: ATSUStyle): OSStatus; C;
  483. FUNCTION ATSUSetStyleRefCon(iStyle: ATSUStyle; iRefCon: UInt32): OSStatus; C;
  484. FUNCTION ATSUGetStyleRefCon(iStyle: ATSUStyle; VAR oRefCon: UInt32): OSStatus; C;
  485. {    Style comparison         }
  486. FUNCTION ATSUCompareStyles(iFirstStyle: ATSUStyle; iSecondStyle: ATSUStyle; VAR oComparison: ATSUStyleComparison): OSStatus; C;
  487. {    Attribute manipulations    }
  488. FUNCTION ATSUCopyAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  489. FUNCTION ATSUOverwriteAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  490. FUNCTION ATSUUnderwriteAttributes(iSourceStyle: ATSUStyle; iDestinationStyle: ATSUStyle): OSStatus; C;
  491. {    Empty styles    }
  492. FUNCTION ATSUClearStyle(iStyle: ATSUStyle): OSStatus; C;
  493. FUNCTION ATSUStyleIsEmpty(iStyle: ATSUStyle; VAR oIsClear: BOOLEAN): OSStatus; C;
  494. {    Get and set attributes }
  495. FUNCTION ATSUCalculateBaselineDeltas(iStyle: ATSUStyle; iBaselineClass: BslnBaselineClass; VAR oBaselineDeltas: BslnBaselineRecord): OSStatus; C;
  496. FUNCTION ATSUSetAttributes(iStyle: ATSUStyle; iAttributeCount: ItemCount; VAR iTag: ATSUAttributeTag; VAR iValueSize: ByteCount; VAR iValue: ATSUAttributeValuePtr): OSStatus; C;
  497. FUNCTION ATSUGetAttribute(iStyle: ATSUStyle; iTag: ATSUAttributeTag; iExpectedValueSize: ByteCount; oValue: ATSUAttributeValuePtr; VAR oActualValueSize: ByteCount): OSStatus; C;
  498. FUNCTION ATSUGetAllAttributes(iStyle: ATSUStyle; VAR oAttributeInfoArray: ATSUAttributeInfo; iTagValuePairArraySize: ItemCount; VAR oTagValuePairCount: ItemCount): OSStatus; C;
  499. FUNCTION ATSUClearAttributes(iStyle: ATSUStyle; iTagCount: ItemCount; VAR iTag: ATSUAttributeTag): OSStatus; C;
  500. {    Font features    }
  501. FUNCTION ATSUSetFontFeatures(iStyle: ATSUStyle; iFeatureCount: ItemCount; VAR iType: ATSUFontFeatureType; VAR iSelector: ATSUFontFeatureSelector): OSStatus; C;
  502. FUNCTION ATSUGetFontFeature(iStyle: ATSUStyle; iFeatureIndex: ItemCount; VAR oFeatureType: ATSUFontFeatureType; VAR oFeatureSelector: ATSUFontFeatureSelector): OSStatus; C;
  503. FUNCTION ATSUGetAllFontFeatures(iStyle: ATSUStyle; iMaximumFeatureCount: ItemCount; VAR oFeatureType: ATSUFontFeatureType; VAR oFeatureSelector: ATSUFontFeatureSelector; VAR oActualFeatureCount: ItemCount): OSStatus; C;
  504. FUNCTION ATSUClearFontFeatures(iStyle: ATSUStyle; iFeatureCount: ItemCount; VAR iType: ATSUFontFeatureType; VAR iSelector: ATSUFontFeatureSelector): OSStatus; C;
  505. {    Font variations    }
  506. FUNCTION ATSUSetVariations(iStyle: ATSUStyle; iVariationCount: ItemCount; VAR iAxes: ATSUFontVariationAxis; VAR iValue: ATSUFontVariationValue): OSStatus; C;
  507. FUNCTION ATSUGetFontVariationValue(iStyle: ATSUStyle; iFontVariationAxis: ATSUFontVariationAxis; VAR oFontVariationValue: ATSUFontVariationValue): OSStatus; C;
  508. FUNCTION ATSUGetAllFontVariations(iStyle: ATSUStyle; iVariationCount: ItemCount; VAR oVariationAxes: ATSUFontVariationAxis; VAR oFontVariationValues: ATSUFontVariationValue; VAR oActualVariationCount: ItemCount): OSStatus; C;
  509. FUNCTION ATSUClearFontVariations(iStyle: ATSUStyle; iAxisCount: ItemCount; VAR iAxis: ATSUFontVariationAxis): OSStatus; C;
  510. {    Basic text-layout functions    }
  511. FUNCTION ATSUCreateTextLayout(VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  512. FUNCTION ATSUCreateAndCopyTextLayout(iTextLayout: ATSUTextLayout; VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  513. FUNCTION ATSUCreateTextLayoutWithTextPtr(iText: ConstUniCharArrayPtr; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount; iNumberOfRuns: ItemCount; VAR iRunLengths: UniCharCount; VAR iStyles: ATSUStyle; VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  514. FUNCTION ATSUCreateTextLayoutWithTextHandle(iText: UniCharArrayHandle; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount; iNumberOfRuns: ItemCount; VAR iRunLengths: UniCharCount; VAR iStyles: ATSUStyle; VAR oTextLayout: ATSUTextLayout): OSStatus; C;
  515. FUNCTION ATSUClearLayoutCache(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset): OSStatus; C;
  516. FUNCTION ATSUDisposeTextLayout(iTextLayout: ATSUTextLayout): OSStatus; C;
  517. FUNCTION ATSUSetTextLayoutRefCon(iTextLayout: ATSUTextLayout; iRefCon: UInt32): OSStatus; C;
  518. FUNCTION ATSUGetTextLayoutRefCon(iTextLayout: ATSUTextLayout; VAR oRefCon: UInt32): OSStatus; C;
  519. {    Glyph bounds retrieval    }
  520. FUNCTION ATSUGetGlyphBounds(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iBoundsCharStart: UniCharArrayOffset; iBoundsCharLength: UniCharCount; iTypeOfBounds: UInt16; iMaxNumberOfBounds: ItemCount; VAR oGlyphBounds: ATSTrapezoid; VAR oActualNumberOfBounds: ItemCount): OSStatus; C;
  521. {    Idle processing    }
  522. FUNCTION ATSUIdle(iTextLayout: ATSUTextLayout): OSStatus; C;
  523. {    Text location    }
  524. FUNCTION ATSUSetTextPointerLocation(iTextLayout: ATSUTextLayout; iText: ConstUniCharArrayPtr; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount): OSStatus; C;
  525. FUNCTION ATSUSetTextHandleLocation(iTextLayout: ATSUTextLayout; iText: UniCharArrayHandle; iTextOffset: UniCharArrayOffset; iTextLength: UniCharCount; iTextTotalLength: UniCharCount): OSStatus; C;
  526. FUNCTION ATSUGetTextLocation(iTextLayout: ATSUTextLayout; VAR oText: UNIV Ptr; VAR oTextIsStoredInHandle: BOOLEAN; VAR oOffset: UniCharArrayOffset; VAR oTextLength: UniCharCount; VAR oTextTotalLength: UniCharCount): OSStatus; C;
  527. {    Text manipulation    }
  528. FUNCTION ATSUTextDeleted(iTextLayout: ATSUTextLayout; iDeletedRangeStart: UniCharArrayOffset; iDeletedRangeLength: UniCharCount): OSStatus; C;
  529. FUNCTION ATSUTextInserted(iTextLayout: ATSUTextLayout; iInsertionLocation: UniCharArrayOffset; iInsertionLength: UniCharCount): OSStatus; C;
  530. FUNCTION ATSUTextMoved(iTextLayout: ATSUTextLayout; iNewLocation: ConstUniCharArrayPtr): OSStatus; C;
  531. {    Layout controls    }
  532. FUNCTION ATSUCopyLayoutControls(iSourceTextLayout: ATSUTextLayout; iDestTextLayout: ATSUTextLayout): OSStatus; C;
  533. FUNCTION ATSUSetLayoutControls(iTextLayout: ATSUTextLayout; iAttributeCount: ItemCount; VAR iTag: ATSUAttributeTag; VAR iValueSize: ByteCount; VAR iValue: ATSUAttributeValuePtr): OSStatus; C;
  534. FUNCTION ATSUGetLayoutControl(iTextLayout: ATSUTextLayout; iTag: ATSUAttributeTag; iExpectedValueSize: ByteCount; oValue: ATSUAttributeValuePtr; VAR oActualValueSize: ByteCount): OSStatus; C;
  535. FUNCTION ATSUGetAllLayoutControls(iTextLayout: ATSUTextLayout; VAR oAttributeInfoArray: ATSUAttributeInfo; iTagValuePairArraySize: ItemCount; VAR oTagValuePairCount: ItemCount): OSStatus; C;
  536. FUNCTION ATSUClearLayoutControls(iTextLayout: ATSUTextLayout; iTagCount: ItemCount; VAR iTag: ATSUAttributeTag): OSStatus; C;
  537. {    Single line layout controls    }
  538. FUNCTION ATSUCopyLineControls(iSourceTextLayout: ATSUTextLayout; iSourceLineStart: UniCharArrayOffset; iDestTextLayout: ATSUTextLayout; iDestLineStart: UniCharArrayOffset): OSStatus; C;
  539. FUNCTION ATSUSetLineControls(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iAttributeCount: ItemCount; VAR iTag: ATSUAttributeTag; VAR iValueSize: ByteCount; VAR iValue: ATSUAttributeValuePtr): OSStatus; C;
  540. FUNCTION ATSUGetLineControl(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iTag: ATSUAttributeTag; iExpectedValueSize: ByteCount; oValue: ATSUAttributeValuePtr; VAR oActualValueSize: ByteCount): OSStatus; C;
  541. FUNCTION ATSUGetAllLineControls(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; VAR oAttributeInfoArray: ATSUAttributeInfo; iTagValuePairArraySize: ItemCount; VAR oTagValuePairCount: ItemCount): OSStatus; C;
  542. FUNCTION ATSUClearLineControls(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iTagCount: ItemCount; VAR iTag: ATSUAttributeTag): OSStatus; C;
  543. {    Style run processing    }
  544. FUNCTION ATSUSetRunStyle(iTextLayout: ATSUTextLayout; iStyle: ATSUStyle; iRunStart: UniCharArrayOffset; iRunLength: UniCharCount): OSStatus; C;
  545. FUNCTION ATSUGetRunStyle(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; VAR oStyle: ATSUStyle; VAR oRunStart: UniCharArrayOffset; VAR oRunLength: UniCharCount): OSStatus; C;
  546. FUNCTION ATSUGetContinuousAttributes(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; iLength: UniCharCount; oStyle: ATSUStyle): OSStatus; C;
  547. {    Drawing and measuring    }
  548. FUNCTION ATSUDrawText(iTextLayout: ATSUTextLayout; iLineOffset: UniCharArrayOffset; iLineLength: UniCharCount; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement): OSStatus; C;
  549. FUNCTION ATSUMeasureText(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iLineLength: UniCharCount; VAR oTextBefore: ATSUTextMeasurement; VAR oTextAfter: ATSUTextMeasurement; VAR oAscent: ATSUTextMeasurement; VAR oDescent: ATSUTextMeasurement): OSStatus; C;
  550. FUNCTION ATSUMeasureTextImage(iTextLayout: ATSUTextLayout; iLineOffset: UniCharArrayOffset; iLineLength: UniCharCount; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement; VAR oTextImageRect: Rect): OSStatus; C;
  551. {    Highlighting    }
  552. FUNCTION ATSUHighlightText(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount): OSStatus; C;
  553. FUNCTION ATSUUnhighlightText(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount): OSStatus; C;
  554. FUNCTION ATSUGetTextHighlight(iTextLayout: ATSUTextLayout; iTextBasePointX: ATSUTextMeasurement; iTextBasePointY: ATSUTextMeasurement; iHighlightStart: UniCharArrayOffset; iHighlightLength: UniCharCount; oHighlightRegion: RgnHandle): OSStatus; C;
  555. {    Hit-testing    }
  556. FUNCTION ATSUPositionToOffset(iTextLayout: ATSUTextLayout; iLocationX: ATSUTextMeasurement; iLocationY: ATSUTextMeasurement; VAR ioPrimaryOffset: UniCharArrayOffset; VAR oIsLeading: BOOLEAN; VAR oSecondaryOffset: UniCharArrayOffset): OSStatus; C;
  557. FUNCTION ATSUOffsetToPosition(iTextLayout: ATSUTextLayout; iOffset: UniCharArrayOffset; iIsLeading: BOOLEAN; VAR oMainCaret: ATSUCaret; VAR oSecondCaret: ATSUCaret; VAR oCaretIsSplit: BOOLEAN): OSStatus; C;
  558. {    Cursor movement    }
  559. FUNCTION ATSUNextCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  560. FUNCTION ATSUPreviousCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  561. FUNCTION ATSURightwardCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  562. FUNCTION ATSULeftwardCursorPosition(iTextLayout: ATSUTextLayout; iOldOffset: UniCharArrayOffset; iMovementType: ATSUCursorMovementType; VAR oNewOffset: UniCharArrayOffset): OSStatus; C;
  563. {    Line breaking    }
  564. FUNCTION ATSUBreakLine(iTextLayout: ATSUTextLayout; iLineStart: UniCharArrayOffset; iLineWidth: ATSUTextMeasurement; iUseAsSoftLineBreak: BOOLEAN; VAR oLineBreak: UniCharArrayOffset): OSStatus; C;
  565. FUNCTION ATSUSetSoftLineBreak(iTextLayout: ATSUTextLayout; iLineBreak: UniCharArrayOffset): OSStatus; C;
  566. FUNCTION ATSUGetSoftLineBreaks(iTextLayout: ATSUTextLayout; iRangeStart: UniCharArrayOffset; iRangeLength: UniCharCount; iMaximumBreaks: ItemCount; VAR oBreaks: UniCharArrayOffset; VAR oBreakCount: ItemCount): OSStatus; C;
  567. FUNCTION ATSUClearSoftLineBreaks(iTextLayout: ATSUTextLayout; iRangeStart: UniCharArrayOffset; iRangeLength: UniCharCount): OSStatus; C;
  568. {    Font matching    }
  569. FUNCTION ATSUSetFontFallbacks(iFontFallbacksCount: ItemCount; VAR iFontIDs: ATSUFontID; iFontFallbackMethod: ATSUFontFallbackMethod): OSStatus; C;
  570. FUNCTION ATSUGetFontFallbacks(iMaxFontFallbacksCount: ItemCount; VAR oFontIDs: ATSUFontID; VAR oFontFallbackMethod: ATSUFontFallbackMethod; VAR oActualFallbacksCount: ItemCount): OSStatus; C;
  571. FUNCTION ATSUMatchFontsToText(iTextLayout: ATSUTextLayout; iTextStart: UniCharArrayOffset; iTextLength: UniCharCount; VAR oFontID: ATSUFontID; VAR oChangedOffset: UniCharArrayOffset; VAR oChangedLength: UniCharCount): OSStatus; C;
  572. FUNCTION ATSUSetTransientFontMatching(iTextLayout: ATSUTextLayout; iTransientFontMatching: BOOLEAN): OSStatus; C;
  573. FUNCTION ATSUGetTransientFontMatching(iTextLayout: ATSUTextLayout; VAR oTransientFontMatching: BOOLEAN): OSStatus; C;
  574. {    Font ID's    }
  575. FUNCTION ATSUFontCount(VAR oFontCount: ItemCount): OSStatus; C;
  576. FUNCTION ATSUGetFontIDs(VAR oFontIDs: ATSUFontID; iArraySize: ItemCount; VAR oFontCount: ItemCount): OSStatus; C;
  577. FUNCTION ATSUFONDtoFontID(iFONDNumber: INTEGER; iFONDStyle: ByteParameter; VAR oFontID: ATSUFontID): OSStatus; C;
  578. FUNCTION ATSUFontIDtoFOND(iFontID: ATSUFontID; VAR oFONDNumber: INTEGER; VAR oFONDStyle: Style): OSStatus; C;
  579. {    Font names    }
  580. FUNCTION ATSUCountFontNames(iFontID: ATSUFontID; VAR oFontNameCount: ItemCount): OSStatus; C;
  581. FUNCTION ATSUGetIndFontName(iFontID: ATSUFontID; iFontNameIndex: ItemCount; iMaximumNameLength: ByteCount; oName: Ptr; VAR oActualNameLength: ByteCount; VAR oFontNameCode: FontNameCode; VAR oFontNamePlatform: FontPlatformCode; VAR oFontNameScript: FontScriptCode; VAR oFontNameLanguage: FontLanguageCode): OSStatus; C;
  582. FUNCTION ATSUFindFontName(iFontID: ATSUFontID; iFontNameCode: FontNameCode; iFontNamePlatform: FontPlatformCode; iFontNameScript: FontScriptCode; iFontNameLanguage: FontLanguageCode; iMaximumNameLength: ByteCount; oName: Ptr; VAR oActualNameLength: ByteCount; VAR oFontNameIndex: ItemCount): OSStatus; C;
  583. FUNCTION ATSUFindFontFromName(iName: Ptr; iNameLength: ByteCount; iFontNameCode: FontNameCode; iFontNamePlatform: FontPlatformCode; iFontNameScript: FontScriptCode; iFontNameLanguage: FontLanguageCode; VAR oFontID: ATSUFontID): OSStatus; C;
  584. {    Font features    }
  585. FUNCTION ATSUCountFontFeatureTypes(iFontID: ATSUFontID; VAR oTypeCount: ItemCount): OSStatus; C;
  586. FUNCTION ATSUCountFontFeatureSelectors(iFontID: ATSUFontID; iType: ATSUFontFeatureType; VAR oSelectorCount: ItemCount): OSStatus; C;
  587. FUNCTION ATSUGetFontFeatureTypes(iFontID: ATSUFontID; iMaximumTypes: ItemCount; VAR oTypes: ATSUFontFeatureType; VAR oActualTypeCount: ItemCount): OSStatus; C;
  588. FUNCTION ATSUGetFontFeatureSelectors(iFontID: ATSUFontID; iType: ATSUFontFeatureType; iMaximumSelectors: ItemCount; VAR oSelectors: ATSUFontFeatureSelector; VAR oSelectorIsOnByDefault: BOOLEAN; VAR oActualSelectorCount: ItemCount; VAR oIsMutuallyExclusive: BOOLEAN): OSStatus; C;
  589. FUNCTION ATSUGetFontFeatureNameCode(iFontID: ATSUFontID; iType: ATSUFontFeatureType; iSelector: ATSUFontFeatureSelector; VAR oNameCode: FontNameCode): OSStatus; C;
  590. {    Font tracking value & names    }
  591. FUNCTION ATSUCountFontTracking(iFontID: ATSUFontID; iCharacterOrientation: ATSUVerticalCharacterType; VAR oTrackingCount: ItemCount): OSStatus; C;
  592. FUNCTION ATSUGetIndFontTracking(iFontID: ATSUFontID; iCharacterOrientation: ATSUVerticalCharacterType; iTrackIndex: ItemCount; VAR oFontTrackingValue: Fixed; VAR oNameCode: FontNameCode): OSStatus; C;
  593. {    Font variations    }
  594. FUNCTION ATSUCountFontVariations(iFontID: ATSUFontID; VAR oVariationCount: ItemCount): OSStatus; C;
  595. FUNCTION ATSUGetIndFontVariation(iFontID: ATSUFontID; iVariationIndex: ItemCount; VAR oATSUFontVariationAxis: ATSUFontVariationAxis; VAR oMinimumValue: ATSUFontVariationValue; VAR oMaximumValue: ATSUFontVariationValue; VAR oDefaultValue: ATSUFontVariationValue): OSStatus; C;
  596. FUNCTION ATSUGetFontVariationNameCode(iFontID: ATSUFontID; iAxis: ATSUFontVariationAxis; VAR oNameCode: FontNameCode): OSStatus; C;
  597. {    Font Instances    }
  598. FUNCTION ATSUCountFontInstances(iFontID: ATSUFontID; VAR oInstances: ItemCount): OSStatus; C;
  599. FUNCTION ATSUGetFontInstance(iFontID: ATSUFontID; iFontInstanceIndex: ItemCount; iMaximumVariations: ItemCount; VAR oAxes: ATSUFontVariationAxis; VAR oValues: ATSUFontVariationValue; VAR oActualVariationCount: ItemCount): OSStatus; C;
  600. FUNCTION ATSUGetFontInstanceNameCode(iFontID: ATSUFontID; iInstanceIndex: ItemCount; VAR oNameCode: FontNameCode): OSStatus; C;
  601. {$ALIGN RESET}
  602. {$POP}
  603.  
  604. {$SETC UsingIncludes := ATSUnicodeIncludes}
  605.  
  606. {$ENDC} {__ATSUNICODE__}
  607.  
  608. {$IFC NOT UsingIncludes}
  609.  END.
  610. {$ENDC}
  611.